\documentclass{article}

\usepackage[utf8]{inputenc} 
\usepackage[T1]{fontenc}   
\usepackage{graphicx}  

\usepackage{lmodern}
\usepackage[french]{babel}
\usepackage{subfig}
\usepackage{amsmath}
%\usepackage{graphicx}
\usepackage{caption}
\usepackage{amssymb}
\usepackage{amsthm}
\usepackage{shapepar}
\usepackage{epstopdf}
\usepackage{tabularx}
\usepackage{url}
\usepackage{qtree}
\usepackage{listings}
\usepackage{algpseudocode}
\usepackage{eurosym}
\usepackage{array}
\usepackage[table]{xcolor}
\usepackage{wasysym}
\usepackage{float}
\usepackage{multirow} 


\begin{document}
\newcommand{\code}[1]{\texttt{\textbf{#1}}}
%\title{LINGI2263 – Computational Linguistics\\
%Text Categorization - N-gram language models}
%\author{Jérémie HAMBYE \and Group 4 \and Ludovic GUSTIN}
%\maketitle
\lstset{language=Java}

\newcommand{\question}[1]{\vspace{0.5cm} \indent\textbf{#1} \par \vspace{0.3cm}}
\newcommand{\astar}{A$^{\star}$ }

\begin{center}
 \vspace*{-2cm}

March 2012 \\Année Académique 2011-2012\\\vspace*{1cm}
% Upper part of the page
\includegraphics[width=0.15\textwidth]{images/logo-epl.png}\\[1cm]
 
	\textsc{\LARGE École Polytechnique de Louvain}\\[1.5cm]
 
%\textsc{\Large \texttt{FSAB1202 - FSAB1301 - FSAB1502}\\APP Interdisciplinaire - Rapport}\\[0.5cm]
 
 
% Title
\vspace{1.5cm}
{\begin{large} \texttt{INGI2132} \end{large}\\ \vspace{0.8cm}\huge{Phase 2 - Interpréteur}}\\[0.4cm]
\large{Langage \textsc{Fanta}}\\
 
\vspace{6.5cm}
 
% Author and supervisor

\begin{minipage}{0.5\textwidth}
\begin{flushright} \large
%\emph{Students :} \\
Jérémie \textsc{Hambÿe}\\
Thoralf \textsc{Gutierrez}\\
Sébastien \textsc{De Wolf}\\
Group 17\\
\end{flushright}
\end{minipage}

\end{center}

\newpage

\textit{Le code source est fait en Java. JDK et JRE sont requis pour compiler et exécuter le code.}

\section{Instructions d'exécution}

Il faut lancer le script \code{script.sh} qui doit se trouver dans le même dossier que le dossier des sources.

La commande \code{./script.sh compile} sert à compiler les fichiers .java des sources en fichiers .class.

La commande \code{./script.sh clean} sert à supprimer ces fichiers .class.

Les tests sont lancés à l'aide de la commande \code{./script.sh test TYPE} où \code{TYPE} peut être:

\begin{list}{}{}
\item \code{op} : tests sur les opérations $+$,$-$,$*$,$/$ et modulo
\item \code{gates} : tests sur les trois portes logiques NOT, AND et OR
\item \code{io} : tests les entrées et sorties
\item \code{function} : test sur les fonction avec le calcul des 10 premiers nombres de Fibonacci
\item \code{case} : tests sur le bloc case of ...
\item \code{if } : tests sur les tests if
\item \code{while } : tests sur les boucles while

\end{list}

\section{Architecture du programme}

Le programme compte quatre éléments principaux: 
\begin{list}{}{}
\item Environment
\item Identifier
\item Interpreter
\item AST
\end{list}

Environment est une classe qui définit les environnement utilisés lors de l'interprétation d'un AST. Il s'agit d'une HashMap qui lie des clés (les noms des identifiers) à des valeurs (interface Value, expliqué plus loin).

Identifier est une classe qui définit ce qu'est un identificateur dans nos AST: c'est une simple String.

Interpreter est la classe qui contient la fonction \code{instr}, appelée pour interpréter une instruction.

AST est une interface qui est étendue par trois autres interfaces :
\begin{list}{-}{}
\item \code{Expression}
\item \code{Instruction}
\item \code{Value}
\end{list}

Chacune de ces interfaces correspond à un type d'élément du langage:

\subsection*{Expression}

Cette interface est utilisée pour toutes les expressions du langage:

\begin{list}{-}{}
\item Les opérations arithmétiques
	\begin{list}{}{}
	\item Add : \code{a + b}
	\item Divide : \code{a / b}
	\item Substract :  \code{a - b}
	\item Multiply : \code{a * b}
	\item Modulo : \code{a \% b}
	\end{list}
\item Les portes logiques
	\begin{list}{}{}
	\item AndGate : \code{a \&\& b}
	\item OrGate : \code{a || b}
	\item NotGate : \code{!a}
	\end{list}
\item Les opérations de comparaison
	\begin{list}{}{}
	\item Equal : \code{a == b}
	\item Different : \code{a != b}
	\item Greater : \code{a > b}
	\item GreaterEqual : \code{a >= b}
	\item Less : \code{a < b}
	\item LessEqual : \code {a <= b}	
	\end{list}
\item L'opération de lecture : Input :  \code{input()} qui lit une saisie de l'utilisateur sur l'entrée standard et le parse pour renvoyer une Value.
\item Les opérations d'accès de variable:
	\begin{list}{}{}
	\item VariableAccess : \code{x} (où x est supposée être un identificateur)
	\item ArrayAccess : \code{x$[$i$]$} (idem)	
	\end{list}
\end{list}

Toutes les expressions implémentent la fonction \code{eval(Environment env)} qui renvoie la valeur de l'expression sous la forme d'une Value.

\subsection*{Instruction}
De la même manière, cette interface est utilisée pour décrire les différentes instructions:

\begin{list}{-}{}
\item La composition d'instructions: Composition : \code{instr1 instr2}
\item Les tests:
	\begin{list}{}{}
	\item If : \code{if (test) \{ instr$_{true}$ \} else \{ instr$_{false}$ \}}
	\item While : \code{while (test) \{ instr \}}
	\item Case : \code{case (x) of pattern  \{ instr$_{match}$ \} else \{ instr$_{fail}$ \}}
	\end{list}
\item Les définitions:
	\begin{list}{}{}
	\item Local : \code{local(x) \{ body \}}
	\item ArrayDef : \code{x = [a b c]}
	\item FunctionDef : \code{def name(args) \{ body \}}
	\end{list}
\item Les assignations de valeurs:
	\begin{list}{}{}
	\item VariableAssign : \code{x = a}
	\item ArrayAssign : \code{x$[$i$]$ = a} 
	\end{list}
\item L'appel de fonction: FunctionCall : \code{name(args)}
\item L'affichage : Print : \code{print(x)} qui imprime sur la sortie standard le type de la Value \code{x} et sa valeur.
\end{list}

Toutes ces classes implémentent la fonction \code{instr(Environment)} qui renvoie l'environnement après l'exécution de l'instruction.

\subsection*{Values}
Il s'agit de toutes les types définis dans notre langage:

\begin{list}{-}{}
\item Array : un tableau de taille fixe, passé en référence s'il est utilisé comme argument d'une fonction
\item Boolean : \code{true} ou \code{false}
\item FantaString : une chaîne de caractères
\item Function : une fonction qui a des arguments, une instruction (le corps de la fonction) et un environnement contextuel.
\item Integer : un entier
\end{list}

En plus de ces cinq types, vient s'ajouter un type spécial : 
\begin{list}{-}{}
\item PatternArray : il s'agit des patterns spéciaux des cases qui peuvent contenir des identificateurs non liés, mais qui seront liés si le pattern est matché.
\end{list}

\end{document}
